home *** CD-ROM | disk | FTP | other *** search
/ Freelog 115 / FreelogNo115-MaiJuin2013.iso / Internet / Filezilla Server / FileZilla_Server-0_9_41.exe / source / interface / GroupsDlgSpeedLimit.cpp < prev    next >
C/C++ Source or Header  |  2011-11-06  |  15KB  |  475 lines
  1. // FileZilla Server - a Windows ftp server
  2.  
  3. // Copyright (C) 2002-2004 - Tim Kosse <tim.kosse@gmx.de>
  4.  
  5. // This program is free software; you can redistribute it and/or
  6. // modify it under the terms of the GNU General Public License
  7. // as published by the Free Software Foundation; either version 2
  8. // of the License, or (at your option) any later version.
  9.  
  10. // This program is distributed in the hope that it will be useful,
  11. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. // GNU General Public License for more details.
  14.  
  15. // You should have received a copy of the GNU General Public License
  16. // along with this program; if not, write to the Free Software
  17. // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18.  
  19. // GroupsDlgSpeedLimit.cpp: Implementierungsdatei
  20. //
  21.  
  22. #include "stdafx.h"
  23. #include "filezilla server.h"
  24. #include "GroupsDlgSpeedLimit.h"
  25. #include "SpeedLimitRuleDlg.h"
  26.  
  27. /////////////////////////////////////////////////////////////////////////////
  28. // CGroupsDlgSpeedLimit dialog
  29.  
  30.  
  31. CGroupsDlgSpeedLimit::CGroupsDlgSpeedLimit(CGroupsDlg* pOwner) 
  32.     : CSAPrefsSubDlg(IDD)
  33. {
  34.     m_pOwner = pOwner;
  35.     
  36.     //{{AFX_DATA_INIT(CGroupsDlgSpeedLimit)
  37.     m_DownloadSpeedLimitType = -1;
  38.     m_UploadSpeedLimitType = -1;
  39.     m_DownloadValue = 10;
  40.     m_UploadValue = 10;
  41.     //}}AFX_DATA_INIT
  42. }
  43.  
  44. CGroupsDlgSpeedLimit::~CGroupsDlgSpeedLimit()
  45. {
  46. }
  47.  
  48. void CGroupsDlgSpeedLimit::DoDataExchange(CDataExchange* pDX)
  49. {
  50.     CSAPrefsSubDlg::DoDataExchange(pDX);
  51.     //{{AFX_DATA_MAP(CGroupsDlgSpeedLimit)
  52.     DDX_Control(pDX, IDC_SPEEDLIMIT_DOWNLOAD_UP, m_DownloadUpCtrl);
  53.     DDX_Control(pDX, IDC_SPEEDLIMIT_DOWNLOAD_RULES_LIST, m_DownloadRulesListCtrl);
  54.     DDX_Control(pDX, IDC_SPEEDLIMIT_DOWNLOAD_REMOVE, m_DownloadRemoveCtrl);
  55.     DDX_Control(pDX, IDC_SPEEDLIMIT_DOWNLOAD_DOWN, m_DownloadDownCtrl);
  56.     DDX_Control(pDX, IDC_SPEEDLIMIT_DOWNLOAD_ADD, m_DownloadAddCtrl);
  57.     DDX_Control(pDX, IDC_SPEEDLIMIT_UPLOAD_UP, m_UploadUpCtrl);
  58.     DDX_Control(pDX, IDC_SPEEDLIMIT_UPLOAD_RULES_LIST, m_UploadRulesListCtrl);
  59.     DDX_Control(pDX, IDC_SPEEDLIMIT_UPLOAD_REMOVE, m_UploadRemoveCtrl);
  60.     DDX_Control(pDX, IDC_SPEEDLIMIT_UPLOAD_DOWN, m_UploadDownCtrl);
  61.     DDX_Control(pDX, IDC_SPEEDLIMIT_UPLOAD_ADD, m_UploadAddCtrl);
  62.     DDX_Control(pDX, IDC_SPEEDLIMIT_UPLOAD_VALUE, m_UploadValueCtrl);
  63.     DDX_Control(pDX, IDC_SPEEDLIMIT_DOWNLOAD_VALUE, m_DownloadValueCtrl);
  64.     DDX_Radio(pDX, IDC_SPEEDLIMIT_DOWNLOAD1, m_DownloadSpeedLimitType);
  65.     DDX_Radio(pDX, IDC_SPEEDLIMIT_UPLOAD1, m_UploadSpeedLimitType);
  66.     DDX_Text(pDX, IDC_SPEEDLIMIT_DOWNLOAD_VALUE, m_DownloadValue);
  67.     DDV_MinMaxInt(pDX, m_DownloadValue, 1, 1000000000);
  68.     DDX_Text(pDX, IDC_SPEEDLIMIT_UPLOAD_VALUE, m_UploadValue);
  69.     DDV_MinMaxInt(pDX, m_UploadValue, 1, 1000000000);
  70.     //}}AFX_DATA_MAP
  71. }
  72.  
  73.  
  74. BEGIN_MESSAGE_MAP(CGroupsDlgSpeedLimit, CSAPrefsSubDlg)
  75.     //{{AFX_MSG_MAP(CGroupsDlgSpeedLimit)
  76.     ON_BN_CLICKED(IDC_SPEEDLIMIT_DOWNLOAD1, OnRadio)
  77.     ON_BN_CLICKED(IDC_SPEEDLIMIT_DOWNLOAD_ADD, OnSpeedlimitDownloadAdd)
  78.     ON_BN_CLICKED(IDC_SPEEDLIMIT_DOWNLOAD_REMOVE, OnSpeedlimitDownloadRemove)
  79.     ON_BN_CLICKED(IDC_SPEEDLIMIT_DOWNLOAD_UP, OnSpeedlimitDownloadUp)
  80.     ON_BN_CLICKED(IDC_SPEEDLIMIT_DOWNLOAD_DOWN, OnSpeedlimitDownloadDown)
  81.     ON_LBN_DBLCLK(IDC_SPEEDLIMIT_DOWNLOAD_RULES_LIST, OnDblclkSpeedlimitDownloadRulesList)
  82.     ON_BN_CLICKED(IDC_SPEEDLIMIT_UPLOAD_ADD, OnSpeedlimitUploadAdd)
  83.     ON_BN_CLICKED(IDC_SPEEDLIMIT_UPLOAD_REMOVE, OnSpeedlimitUploadRemove)
  84.     ON_BN_CLICKED(IDC_SPEEDLIMIT_UPLOAD_UP, OnSpeedlimitUploadUp)
  85.     ON_BN_CLICKED(IDC_SPEEDLIMIT_UPLOAD_DOWN, OnSpeedlimitUploadDown)
  86.     ON_BN_CLICKED(IDC_SPEEDLIMIT_UPLOAD1, OnRadio)
  87.     ON_BN_CLICKED(IDC_SPEEDLIMIT_DOWNLOAD2, OnRadio)
  88.     ON_BN_CLICKED(IDC_SPEEDLIMIT_UPLOAD2, OnRadio)
  89.     ON_BN_CLICKED(IDC_SPEEDLIMIT_DOWNLOAD3, OnRadio)
  90.     ON_BN_CLICKED(IDC_SPEEDLIMIT_UPLOAD3, OnRadio)
  91.     ON_BN_CLICKED(IDC_SPEEDLIMIT_DOWNLOAD4, OnRadio)
  92.     ON_BN_CLICKED(IDC_SPEEDLIMIT_UPLOAD4, OnRadio)
  93.     ON_LBN_DBLCLK(IDC_SPEEDLIMIT_UPLOAD_RULES_LIST, OnDblclkSpeedlimitUploadRulesList)
  94.     //}}AFX_MSG_MAP
  95. END_MESSAGE_MAP()
  96.  
  97. /////////////////////////////////////////////////////////////////////////////
  98. // CGroupsDlgSpeedLimit message handlers
  99.  
  100. void CGroupsDlgSpeedLimit::SetCtrlState()
  101. {
  102.     UpdateData(TRUE);
  103.  
  104.     ShowSpeedLimit(m_DownloadRulesListCtrl, m_DownloadSpeedLimits);
  105.     ShowSpeedLimit(m_UploadRulesListCtrl, m_UploadSpeedLimits);
  106.  
  107.     if (!m_pOwner->GetCurrentGroup())
  108.     {
  109.         m_DownloadValueCtrl.EnableWindow(FALSE);
  110.         m_DownloadUpCtrl.EnableWindow(FALSE);
  111.         m_DownloadRulesListCtrl.EnableWindow(FALSE);
  112.         m_DownloadRemoveCtrl.EnableWindow(FALSE);
  113.         m_DownloadDownCtrl.EnableWindow(FALSE);
  114.         m_DownloadAddCtrl.EnableWindow(FALSE);
  115.         
  116.         m_UploadValueCtrl.EnableWindow(FALSE);
  117.         m_UploadUpCtrl.EnableWindow(FALSE);
  118.         m_UploadRulesListCtrl.EnableWindow(FALSE);
  119.         m_UploadRemoveCtrl.EnableWindow(FALSE);
  120.         m_UploadDownCtrl.EnableWindow(FALSE);
  121.         m_UploadAddCtrl.EnableWindow(FALSE);
  122.  
  123.         GetDlgItem(IDC_SPEEDLIMIT_DOWNLOAD1)->EnableWindow(FALSE);
  124.         GetDlgItem(IDC_SPEEDLIMIT_DOWNLOAD2)->EnableWindow(FALSE);
  125.         GetDlgItem(IDC_SPEEDLIMIT_DOWNLOAD3)->EnableWindow(FALSE);
  126.         GetDlgItem(IDC_SPEEDLIMIT_UPLOAD1)->EnableWindow(FALSE);
  127.         GetDlgItem(IDC_SPEEDLIMIT_UPLOAD2)->EnableWindow(FALSE);
  128.         GetDlgItem(IDC_SPEEDLIMIT_UPLOAD3)->EnableWindow(FALSE);
  129.  
  130.         ((CButton *)GetDlgItem(IDC_GROUPS_SPEEDLIMIT_SERVERBYPASS_DOWNLOAD))->EnableWindow(FALSE);
  131.         ((CButton *)GetDlgItem(IDC_GROUPS_SPEEDLIMIT_SERVERBYPASS_UPLOAD))->EnableWindow(FALSE);
  132.     }
  133.     else
  134.     {
  135.         m_DownloadValueCtrl.EnableWindow(m_DownloadSpeedLimitType == 1);
  136.         m_DownloadUpCtrl.EnableWindow(m_DownloadSpeedLimitType == 2);
  137.         m_DownloadRulesListCtrl.EnableWindow(m_DownloadSpeedLimitType == 2);
  138.         m_DownloadRemoveCtrl.EnableWindow(m_DownloadSpeedLimitType == 2);
  139.         m_DownloadDownCtrl.EnableWindow(m_DownloadSpeedLimitType == 2);
  140.         m_DownloadAddCtrl.EnableWindow(m_DownloadSpeedLimitType == 2);
  141.         
  142.         m_UploadValueCtrl.EnableWindow(m_UploadSpeedLimitType == 1);
  143.         m_UploadUpCtrl.EnableWindow(m_UploadSpeedLimitType == 2);
  144.         m_UploadRulesListCtrl.EnableWindow(m_UploadSpeedLimitType == 2);
  145.         m_UploadRemoveCtrl.EnableWindow(m_UploadSpeedLimitType == 2);
  146.         m_UploadDownCtrl.EnableWindow(m_UploadSpeedLimitType == 2);
  147.         m_UploadAddCtrl.EnableWindow(m_UploadSpeedLimitType == 2);
  148.  
  149.         GetDlgItem(IDC_SPEEDLIMIT_DOWNLOAD1)->EnableWindow(TRUE);
  150.         GetDlgItem(IDC_SPEEDLIMIT_DOWNLOAD2)->EnableWindow(TRUE);
  151.         GetDlgItem(IDC_SPEEDLIMIT_DOWNLOAD3)->EnableWindow(TRUE);
  152.         GetDlgItem(IDC_SPEEDLIMIT_UPLOAD1)->EnableWindow(TRUE);
  153.         GetDlgItem(IDC_SPEEDLIMIT_UPLOAD2)->EnableWindow(TRUE);
  154.         GetDlgItem(IDC_SPEEDLIMIT_UPLOAD3)->EnableWindow(TRUE);
  155.     
  156.         ((CButton *)GetDlgItem(IDC_GROUPS_SPEEDLIMIT_SERVERBYPASS_DOWNLOAD))->EnableWindow(TRUE);
  157.         ((CButton *)GetDlgItem(IDC_GROUPS_SPEEDLIMIT_SERVERBYPASS_UPLOAD))->EnableWindow(TRUE);
  158.     }
  159. }
  160.  
  161. BOOL CGroupsDlgSpeedLimit::OnInitDialog() 
  162. {
  163.     CSAPrefsSubDlg::OnInitDialog();
  164.     
  165.     SetCtrlState();
  166.  
  167.     ShowSpeedLimit( m_DownloadRulesListCtrl, m_DownloadSpeedLimits);
  168.     ShowSpeedLimit( m_UploadRulesListCtrl, m_UploadSpeedLimits);
  169.  
  170.     return TRUE;  // return TRUE unless you set the focus to a control
  171.                   // EXCEPTION: OCX Property Pages should return FALSE
  172. }
  173.  
  174. void CGroupsDlgSpeedLimit::OnRadio() 
  175. {
  176.     SetCtrlState();
  177. }
  178.  
  179. void CGroupsDlgSpeedLimit::OnSpeedlimitDownloadAdd() 
  180. {
  181.     CSpeedLimitRuleDlg dlg;
  182.  
  183.     if ( dlg.DoModal() == IDOK)
  184.     {
  185.         m_DownloadSpeedLimits.push_back(dlg.GetSpeedLimit());
  186.  
  187.         ShowSpeedLimit( m_DownloadRulesListCtrl, m_DownloadSpeedLimits);
  188.     }
  189. }
  190.  
  191. void CGroupsDlgSpeedLimit::ShowSpeedLimit(CListBox &listBox, SPEEDLIMITSLIST &list)
  192. {
  193.     listBox.ResetContent();
  194.  
  195.     for (unsigned int i = 0; i < list.size(); i++)
  196.     {
  197.         CString str;
  198.         
  199.         str.Format(_T( "%dkB/s"), list[i].m_Speed);
  200.  
  201.         CString help;
  202.         
  203.         if (list[i].m_DateCheck)
  204.         {
  205.             CTime t(list[i].m_Date.y, list[i].m_Date.m, list[i].m_Date.d, 0, 0, 0);
  206.             help += t.Format(_T("%x"));
  207.         }
  208.         
  209.         if (list[i].m_FromCheck)
  210.         {
  211.             if (help.GetLength() > 0)
  212.                 help += _T( "; ");
  213.             
  214.             CTime t(2003, 1, 1, list[i].m_FromTime.h, list[i].m_FromTime.m, list[i].m_FromTime.s);
  215.             help += _T("F:") + t.Format( _T("%X"));
  216.         }
  217.         
  218.         if (list[i].m_ToCheck)
  219.         {
  220.             if (help.GetLength() > 0)
  221.                 help += _T( "; ");
  222.             
  223.             CTime t(2003, 1, 1, list[i].m_ToTime.h, list[i].m_ToTime.m, list[i].m_ToTime.s);
  224.             help += _T("T:") + t.Format( _T("%X"));
  225.         }
  226.         
  227.         for (int j = 0; j < 7; j++)
  228.             if (!(list[i].m_Day & (1<<j)))
  229.             {
  230.                 if (help.GetLength() > 0)
  231.                     help += _T( "; ");
  232.                 
  233.                 bool was = false;
  234.                 for ( int k = 0; k < 7; k++)
  235.                 {
  236.                     if ((list[i].m_Day & (1<<k)))
  237.                     {
  238.                         if (was)
  239.                             help += _T(", ");
  240.                         
  241.                         was = true;
  242.                         
  243.                         CTime time(2001, 1, k + 1, 0, 0, 0);
  244.                         
  245.                         help += time.Format(_T("%a"));
  246.                     }
  247.                 }
  248.                 
  249.                 break;
  250.             }
  251.         
  252.         str += _T(" [") + help + _T("]");
  253.         
  254.         listBox.AddString(str);
  255.     }
  256. }
  257.  
  258. void CGroupsDlgSpeedLimit::OnSpeedlimitDownloadRemove() 
  259. {
  260.     int curSel = m_DownloadRulesListCtrl.GetCurSel();
  261.  
  262.     if ( ( curSel >= 0) && ( curSel < (int)m_DownloadSpeedLimits.size()))
  263.     {
  264.         for (SPEEDLIMITSLIST::iterator iter=m_DownloadSpeedLimits.begin(); iter!=m_DownloadSpeedLimits.end(); iter++)
  265.         {
  266.             if (!curSel)
  267.             {
  268.                 m_DownloadSpeedLimits.erase(iter);
  269.                 break;
  270.             }
  271.             curSel--;
  272.         }
  273.  
  274.         ShowSpeedLimit( m_DownloadRulesListCtrl, m_DownloadSpeedLimits);
  275.     }
  276. }
  277.  
  278. void CGroupsDlgSpeedLimit::OnSpeedlimitDownloadUp() 
  279. {
  280.     int curSel = m_DownloadRulesListCtrl.GetCurSel();
  281.  
  282.     if ( ( curSel >= 1) && ( curSel < (int)m_DownloadSpeedLimits.size()))
  283.     {
  284.         CSpeedLimit sl = m_DownloadSpeedLimits[curSel];
  285.         m_DownloadSpeedLimits[curSel] = m_DownloadSpeedLimits[curSel - 1];
  286.         m_DownloadSpeedLimits[curSel - 1] = sl;
  287.  
  288.         ShowSpeedLimit( m_DownloadRulesListCtrl, m_DownloadSpeedLimits);
  289.  
  290.         m_DownloadRulesListCtrl.SetCurSel( curSel - 1);
  291.     }
  292. }
  293.  
  294. void CGroupsDlgSpeedLimit::OnSpeedlimitDownloadDown() 
  295. {
  296.     int curSel = m_DownloadRulesListCtrl.GetCurSel();
  297.  
  298.     if ( ( curSel >= 0) && ( curSel < (int)m_DownloadSpeedLimits.size() - 1))
  299.     {
  300.         CSpeedLimit sl = m_DownloadSpeedLimits[curSel];
  301.         m_DownloadSpeedLimits[curSel] = m_DownloadSpeedLimits[curSel + 1];
  302.         m_DownloadSpeedLimits[curSel + 1] = sl;
  303.  
  304.         ShowSpeedLimit( m_DownloadRulesListCtrl, m_DownloadSpeedLimits);
  305.  
  306.         m_DownloadRulesListCtrl.SetCurSel( curSel + 1);
  307.     }
  308. }
  309.  
  310. void CGroupsDlgSpeedLimit::OnDblclkSpeedlimitDownloadRulesList() 
  311. {
  312.     int curSel = m_DownloadRulesListCtrl.GetCurSel();
  313.  
  314.     if ( ( curSel >= 0) && ( curSel < (int)m_DownloadSpeedLimits.size()))
  315.     {
  316.         CSpeedLimitRuleDlg dlg;
  317.  
  318.         dlg.FillFromSpeedLimit(m_DownloadSpeedLimits[curSel]);
  319.  
  320.         if ( dlg.DoModal() == IDOK)
  321.         {
  322.             m_DownloadSpeedLimits[curSel] = dlg.GetSpeedLimit();
  323.  
  324.             ShowSpeedLimit(m_DownloadRulesListCtrl, m_DownloadSpeedLimits);
  325.             m_DownloadRulesListCtrl.SetCurSel(curSel);
  326.         }
  327.     }
  328. }
  329.  
  330. void CGroupsDlgSpeedLimit::OnSpeedlimitUploadRemove() 
  331. {
  332.     int curSel = m_UploadRulesListCtrl.GetCurSel();
  333.  
  334.     if ( ( curSel >= 0) && ( curSel < (int)m_UploadSpeedLimits.size()))
  335.     {
  336.         for (SPEEDLIMITSLIST::iterator iter=m_UploadSpeedLimits.begin(); iter!=m_UploadSpeedLimits.end(); iter++)
  337.         {
  338.             if (!curSel)
  339.             {
  340.                 m_UploadSpeedLimits.erase(iter);
  341.                 break;
  342.             }
  343.             curSel--;
  344.         }
  345.  
  346.         ShowSpeedLimit( m_UploadRulesListCtrl, m_UploadSpeedLimits);
  347.     }
  348. }
  349.  
  350. void CGroupsDlgSpeedLimit::OnSpeedlimitUploadUp() 
  351. {
  352.     int curSel = m_UploadRulesListCtrl.GetCurSel();
  353.  
  354.     if ( ( curSel >= 1) && ( curSel < (int)m_UploadSpeedLimits.size()))
  355.     {
  356.         CSpeedLimit sl = m_UploadSpeedLimits[curSel];
  357.         m_UploadSpeedLimits[curSel] = m_UploadSpeedLimits[curSel - 1];
  358.         m_UploadSpeedLimits[curSel - 1] = sl;
  359.  
  360.         ShowSpeedLimit( m_UploadRulesListCtrl, m_UploadSpeedLimits);
  361.  
  362.         m_UploadRulesListCtrl.SetCurSel( curSel - 1);
  363.     }
  364. }
  365.  
  366. void CGroupsDlgSpeedLimit::OnSpeedlimitUploadDown() 
  367. {
  368.     int curSel = m_UploadRulesListCtrl.GetCurSel();
  369.  
  370.     if ( ( curSel >= 0) && ( curSel < (int)m_UploadSpeedLimits.size() - 1))
  371.     {
  372.         CSpeedLimit sl = m_UploadSpeedLimits[curSel];
  373.         m_UploadSpeedLimits[curSel] = m_UploadSpeedLimits[curSel + 1];
  374.         m_UploadSpeedLimits[curSel + 1] = sl;
  375.  
  376.         ShowSpeedLimit( m_UploadRulesListCtrl, m_UploadSpeedLimits);
  377.  
  378.         m_UploadRulesListCtrl.SetCurSel( curSel + 1);
  379.     }
  380. }
  381.  
  382. void CGroupsDlgSpeedLimit::OnSpeedlimitUploadAdd() 
  383. {
  384.     CSpeedLimitRuleDlg dlg;
  385.  
  386.     if ( dlg.DoModal() == IDOK)
  387.     {
  388.         m_UploadSpeedLimits.push_back( dlg.GetSpeedLimit());
  389.  
  390.         ShowSpeedLimit( m_UploadRulesListCtrl, m_UploadSpeedLimits);
  391.     }
  392. }
  393.  
  394. void CGroupsDlgSpeedLimit::OnDblclkSpeedlimitUploadRulesList() 
  395. {
  396.     int curSel = m_UploadRulesListCtrl.GetCurSel();
  397.  
  398.     if ( ( curSel >= 0) && ( curSel < (int)m_UploadSpeedLimits.size()))
  399.     {
  400.         CSpeedLimitRuleDlg dlg;
  401.  
  402.         dlg.FillFromSpeedLimit( m_UploadSpeedLimits[curSel]);
  403.  
  404.         if (dlg.DoModal() == IDOK)
  405.         {
  406.             m_UploadSpeedLimits[curSel] = dlg.GetSpeedLimit();
  407.  
  408.             ShowSpeedLimit( m_UploadRulesListCtrl, m_UploadSpeedLimits);
  409.             m_UploadRulesListCtrl.SetCurSel( curSel);
  410.         }
  411.     }
  412. }
  413.  
  414. BOOL CGroupsDlgSpeedLimit::DisplayGroup(const t_group *pGroup)
  415. {
  416.     if (!pGroup)
  417.     {
  418.         m_DownloadValue = 10;
  419.         m_UploadValue = 10;
  420.         m_DownloadSpeedLimitType = -1;
  421.         m_UploadSpeedLimitType = -1;
  422.  
  423.         m_DownloadSpeedLimits.clear();
  424.         m_UploadSpeedLimits.clear();
  425.  
  426.         ((CButton *)GetDlgItem(IDC_GROUPS_SPEEDLIMIT_SERVERBYPASS_DOWNLOAD))->SetCheck(0);
  427.         ((CButton *)GetDlgItem(IDC_GROUPS_SPEEDLIMIT_SERVERBYPASS_UPLOAD))->SetCheck(0);
  428.     }
  429.     else
  430.     {
  431.         m_DownloadValue = pGroup->nSpeedLimit[download];
  432.         m_UploadValue = pGroup->nSpeedLimit[upload];
  433.         m_DownloadSpeedLimitType = pGroup->nSpeedLimitType[download] - 1;
  434.         if (m_DownloadSpeedLimitType == -1)
  435.             m_DownloadSpeedLimitType = 0;
  436.         m_UploadSpeedLimitType = pGroup->nSpeedLimitType[upload] - 1;
  437.         if (m_UploadSpeedLimitType == -1)
  438.             m_UploadSpeedLimitType = 0;
  439.         
  440.         m_DownloadSpeedLimits = pGroup->SpeedLimits[download];
  441.         m_UploadSpeedLimits = pGroup->SpeedLimits[upload];
  442.     
  443.         ((CButton *)GetDlgItem(IDC_GROUPS_SPEEDLIMIT_SERVERBYPASS_DOWNLOAD))->SetCheck(pGroup->nBypassServerSpeedLimit[download] ? 1 : 0);
  444.         ((CButton *)GetDlgItem(IDC_GROUPS_SPEEDLIMIT_SERVERBYPASS_UPLOAD))->SetCheck(pGroup->nBypassServerSpeedLimit[upload] ? 1 : 0);
  445.     }
  446.  
  447.     UpdateData(FALSE);
  448.  
  449.     return TRUE;
  450. }
  451.  
  452. BOOL CGroupsDlgSpeedLimit::SaveGroup(t_group *pGroup)
  453. {
  454.     UpdateData(TRUE);
  455.     if (m_DownloadValue > 65535)
  456.         m_DownloadValue = 65535;
  457.     if (m_UploadValue > 65535)
  458.         m_UploadValue = 65535;
  459.     pGroup->nSpeedLimit[download] = m_DownloadValue;
  460.     pGroup->nSpeedLimit[upload] = m_UploadValue;
  461.     pGroup->nSpeedLimitType[download] = m_DownloadSpeedLimitType + 1;
  462.     pGroup->nSpeedLimitType[upload] = m_UploadSpeedLimitType + 1;
  463.  
  464.     pGroup->SpeedLimits[download] = m_DownloadSpeedLimits;
  465.     pGroup->SpeedLimits[upload] = m_UploadSpeedLimits;
  466.  
  467.     pGroup->nBypassServerSpeedLimit[download] = ((CButton *)GetDlgItem(IDC_GROUPS_SPEEDLIMIT_SERVERBYPASS_DOWNLOAD))->GetCheck() ? 1 : 0;
  468.     pGroup->nBypassServerSpeedLimit[upload] = ((CButton *)GetDlgItem(IDC_GROUPS_SPEEDLIMIT_SERVERBYPASS_UPLOAD))->GetCheck() ? 1 : 0;
  469.     return TRUE;
  470. }
  471.  
  472. CString CGroupsDlgSpeedLimit::Validate()
  473. {
  474.     return _T("");
  475. }